/**
 * WebSocket通知客户端 - 小程序版
 */
import storage from '@/utils/storage.js';

class WebSocketClient {
    constructor() {
        this.socket = null;
        this.isConnected = false;
        this.reconnectAttempts = 0;
        this.maxReconnectAttempts = 5;
        this.reconnectInterval = 3000;
        this.callbacks = {
            onMessage: null,
            onConnect: null,
            onDisconnect: null,
            onError: null,
            onPickupReady: null // 自提通知回调
        };
    }

    /**
     * 连接WebSocket服务器
     */
    connect() {
        // 关闭现有连接
        if (this.socket) {
            this.socket.close();
        }

        // 获取服务器地址
        let baseUrl = uni.getStorageSync('baseUrl');
        if (!baseUrl) {
            // 如果没有存储的baseUrl，使用默认API地址
            baseUrl = 'http://192.168.1.100:1750'; // 使用实际的服务器IP地址
        }

        // 使用完整的WebSocket URL
        const wsUrl = baseUrl.replace(/^http/, 'ws') + '/api/ws/notifications';

        console.log('正在连接WebSocket:', wsUrl);

        try {
            // 创建WebSocket连接
            uni.connectSocket({
                url: wsUrl,
                success: () => {
                    console.log('WebSocket连接请求已发送');
                },
                fail: (error) => {
                    console.error('WebSocket连接请求失败:', error);
                    this.reconnect();
                }
            });

            // 连接打开事件
            uni.onSocketOpen((res) => {
                console.log('WebSocket连接已建立', res);
                this.isConnected = true;
                this.reconnectAttempts = 0;

                if (this.callbacks.onConnect) {
                    this.callbacks.onConnect();
                }

                // 发送认证消息
                this.sendAuthMessage();
            });

            // 接收消息事件
            uni.onSocketMessage((res) => {
                try {
                    const message = JSON.parse(res.data);
                    console.log('收到WebSocket消息:', message);

                    // 处理认证响应
                    if (message.type === 'AUTH_RESPONSE') {
                        if (message.success) {
                            console.log('WebSocket认证成功');
                        } else {
                            console.error('WebSocket认证失败:', message.message);
                            // 认证失败，尝试重新连接
                            setTimeout(() => {
                                this.connect();
                            }, 3000);
                        }
                    } else {
                        // 处理其他类型的消息
                        this.handleMessage(message);
                    }

                    if (this.callbacks.onMessage) {
                        this.callbacks.onMessage(message);
                    }
                } catch (error) {
                    console.error('解析WebSocket消息失败:', error, res.data);
                }
            });

            // 连接关闭事件
            uni.onSocketClose((res) => {
                console.log('WebSocket连接已关闭', res);
                this.isConnected = false;

                if (this.callbacks.onDisconnect) {
                    this.callbacks.onDisconnect(res);
                }

                this.reconnect();
            });

            // 连接错误事件
            uni.onSocketError((res) => {
                console.error('WebSocket错误:', res);
                this.isConnected = false;

                if (this.callbacks.onError) {
                    this.callbacks.onError(res);
                }

                this.reconnect();
            });
        } catch (error) {
            console.error('WebSocket连接错误:', error);
            this.reconnect();
        }
    }

    /**
     * 发送认证消息
     */
    sendAuthMessage() {
        // 从storage中获取token
        const token = storage.getToken();
        if (token && this.isConnected) {
            console.log('发送WebSocket认证消息');
            this.send({
                type: 'AUTH',
                token: token
            });
        } else if (!token) {
            console.warn('无法发送认证消息: 未找到token');
        } else if (!this.isConnected) {
            console.warn('无法发送认证消息: WebSocket未连接');
        }
    }

    /**
     * 重新连接
     */
    reconnect() {
        if (this.reconnectAttempts < this.maxReconnectAttempts) {
            this.reconnectAttempts++;
            console.log(`尝试重新连接 (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
            setTimeout(() => {
                this.connect();
            }, this.reconnectInterval);
        } else {
            console.log('达到最大重连次数，停止重连');
            // 重置重连尝试次数，以便下次可以重新连接
            setTimeout(() => {
                this.reconnectAttempts = 0;
            }, 60000); // 1分钟后重置
        }
    }

    /**
     * 断开连接
     */
    disconnect() {
        if (this.isConnected) {
            console.log('主动断开WebSocket连接');
            uni.closeSocket();
            this.isConnected = false;
        }
    }

    /**
     * 发送消息
     * @param {Object} data 消息数据
     */
    send(data) {
        if (this.isConnected) {
            uni.sendSocketMessage({
                data: JSON.stringify(data),
                success: () => {
                    console.log('消息发送成功:', data.type);
                },
                fail: (error) => {
                    console.error('消息发送失败:', error);
                    // 如果发送失败，可能是连接已断开，尝试重连
                    if (!this.isConnected) {
                        this.reconnect();
                    }
                }
            });
        } else {
            console.error('WebSocket未连接，无法发送消息');
            // 尝试重新连接
            this.reconnect();
        }
    }

    /**
     * 处理接收到的消息
     * @param {Object} message 消息对象
     */
    handleMessage(message) {
        // 根据消息类型处理
        if (message.type === 'PICKUP_READY') {
            console.log('收到自提通知:', message);

            // 调用自提通知回调
            if (this.callbacks.onPickupReady) {
                this.callbacks.onPickupReady(message);
            }
        }
    }

    /**
     * 设置消息回调
     * @param {Function} callback 消息回调函数
     */
    onMessage(callback) {
        this.callbacks.onMessage = callback;
    }

    /**
     * 设置连接回调
     * @param {Function} callback 连接回调函数
     */
    onConnect(callback) {
        this.callbacks.onConnect = callback;
    }

    /**
     * 设置断开连接回调
     * @param {Function} callback 断开连接回调函数
     */
    onDisconnect(callback) {
        this.callbacks.onDisconnect = callback;
    }

    /**
     * 设置错误回调
     * @param {Function} callback 错误回调函数
     */
    onError(callback) {
        this.callbacks.onError = callback;
    }

    /**
     * 设置自提通知回调
     * @param {Function} callback 自提通知回调函数
     */
    onPickupReady(callback) {
        this.callbacks.onPickupReady = callback;
    }

    /**
     * 检查WebSocket连接状态
     */
    checkConnection() {
        if (!this.isConnected) {
            console.log('检测到WebSocket未连接，尝试重连');
            this.reconnect();
        }
    }
}

// 创建单例
const websocketClient = new WebSocketClient();

export default websocketClient;